home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / utils / text / showtext.06 / showtext / showtext-0.06 / showtext.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-22  |  26.1 KB  |  1,228 lines
  1. /*
  2.     showtext : shows text in "curses mode"
  3.     Copyright (C) 1995  Rolf Jakob <rjakob@duffy1.franken.de>
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. */
  20. #include <stdio.h>
  21. #include <ncurses/ncurses.h>
  22. #include <stdlib.h>
  23. #include <unistd.h>
  24. #include <errno.h>
  25. #include <string.h>
  26. #include <fcntl.h>
  27. #include <ctype.h>
  28. #include <time.h>
  29. #include <signal.h>
  30. #include "showdefs.h"
  31. #include "show.h"
  32.  
  33. /*
  34. #define DEBUG    1
  35. */
  36.  
  37. #ifdef DEBUG
  38. FILE *df;
  39. #endif
  40. int term=0;
  41. static int my_sig=0;
  42.  
  43. WINDOW *w;
  44.  
  45.  
  46. extern char *getword();
  47.  
  48. struct strbuffer_str {
  49.     char buffername[16];
  50.     char buffer[MAXSTRBUFFERLENGTH];
  51. } strb[MAXSTRBUFFER];
  52.  
  53. char *strcpy_labelname(char *dest, char *src, char c)
  54. {
  55. char *d,*s;
  56.  
  57.     d=dest; s=src;
  58.     while (*s) {
  59.         if (*s=='$') {
  60.             s++;
  61.             switch(*s) {
  62.                 case 'g' :
  63.                     *d=c; break;
  64.                 }
  65.             } else *d=*s;
  66.             s++; d++;
  67.         }
  68.     *d=*s;
  69.     return(dest);
  70. }
  71. /*-------------------------------------------------------------*/
  72.  
  73. /* checks existance of a var 
  74.    returns -1 if not found else internal index
  75. */
  76. int checkvar(char *name)
  77. {
  78. int i=0,found=-1;
  79. char word[64];
  80.  
  81.     if (!*name) return(-1);
  82.     strncpy(word,name,MAXNAMELENGTH);
  83.     word[MAXNAMELENGTH-1]=0;
  84.  
  85.     for (i=0;i<MAXSTRBUFFER;i++)
  86.         if (!strcmp(strb[i].buffername,word)) {
  87.             found=i; break;
  88.             }
  89.     return(found);
  90. }
  91. /*-------------------------------------------------------------*/
  92.  
  93. /* searches free space in var table
  94.    returns -1 if no space else internal index
  95. */
  96. int emptyvar()
  97. {
  98. int i=0,found=-1;
  99.  
  100.     for (i=0;i<MAXSTRBUFFER;i++)
  101.         if (!strb[i].buffername[0]) {
  102.             found=i; break;
  103.             }
  104.     return(found);
  105. }
  106. /*-------------------------------------------------------------*/
  107.  
  108. /* sets var to value
  109.    returns -1 if not set else internal index
  110. */
  111. int setvar(char *name,char *buffer)
  112. {
  113. int i=0;
  114. char word[64];
  115.  
  116.     if (!*name) {
  117. #ifdef DEBUG
  118.         fprintf(df,"no name for value %s\n",buffer);
  119. #endif
  120.         return(-1);
  121.         }
  122.     strncpy(word,name,MAXNAMELENGTH);
  123.     word[MAXNAMELENGTH-1]=0;
  124.  
  125.     i=checkvar(word);
  126.     if(i<0) i=emptyvar();
  127.     if(i<0) {
  128. #ifdef DEBUG
  129.         fprintf(df,"no place for %s, value %s\n",word,buffer);
  130. #endif
  131.         return(-1);
  132.         } else strcpy(strb[i].buffername,word);
  133.  
  134.     strcpy(strb[i].buffer,buffer);
  135. #ifdef DEBUG
  136.     fprintf(df,"set %s to %s\n",strb[i].buffername,buffer);
  137. #endif
  138.     return(i);
  139. }
  140. /*-------------------------------------------------------------*/
  141.  
  142. /* deletes var
  143.    returns -1 if not set else internal index
  144. */
  145. int unsetvar(char *name)
  146. {
  147. int i=0;
  148. char word[64];
  149.  
  150.     if (!*name) return(-1);
  151.     strncpy(word,name,MAXNAMELENGTH);
  152.     word[MAXNAMELENGTH-1]=0;
  153.  
  154.     i=checkvar(word);
  155.     if(i<0) return(-1);
  156.  
  157.     strb[i].buffername[0]=0;
  158.     return(i);
  159. }
  160. /*-------------------------------------------------------------*/
  161.  
  162. /* gets value of var
  163.    returns pointer to buffer
  164. */
  165. char *getvar(char *name,char *buffer)
  166. {
  167. int i=0,rc;
  168. char word[64],help2[512];
  169. struct tm *t;
  170. time_t ti;
  171.  
  172. #ifdef DEBUG
  173.     fprintf(df,"getvar(%s)\n",name);
  174. #endif
  175.     if (!*name) {
  176.         *buffer=0;
  177.         return(buffer);
  178.         }
  179.     strncpy(word,name,MAXNAMELENGTH);
  180.     word[MAXNAMELENGTH-1]=0;
  181.  
  182.     if (!strcmp(word,"_hour")) {
  183.         ti=time(NULL); t=localtime(&ti);
  184.         sprintf(buffer,"%d",t->tm_hour);
  185.         return(buffer);
  186.         }
  187.  
  188.     if (!strcmp(word,"_min")) {
  189.         ti=time(NULL); t=localtime(&ti);
  190.         sprintf(buffer,"%d",t->tm_min);
  191.         return(buffer);
  192.         }
  193.     if (!strcmp(word,"_time")) {
  194.         sprintf(buffer,"%d",(int)time(NULL));
  195.         return(buffer);
  196.         }
  197.  
  198.     if (!strcmp(word,"_curx")) {
  199.         sprintf(buffer,"%d",w->_curx); return(buffer); }
  200.  
  201.     if (!strcmp(word,"_maxx")) {
  202.         sprintf(buffer,"%d",w->_maxx); return(buffer); }
  203.  
  204.     if (!strcmp(word,"_cury")) {
  205.         sprintf(buffer,"%d",w->_cury); return(buffer); }
  206.  
  207.     if (!strcmp(word,"_maxy")) {
  208.         sprintf(buffer,"%d",w->_maxy); return(buffer); }
  209.  
  210.     if (!strcmp(word,"_pid")) {
  211.         sprintf(buffer,"%d",getpid()); return(buffer); }
  212.  
  213.     if (!strcmp(word,"_left")) {
  214.         rc=atoi(getvar("_time",help2));
  215.         rc-=atoi(getvar("_logon",help2));
  216.         rc=atoi(getvar("_boxtime",help2))-rc/60;
  217.         sprintf(buffer,"%d",rc);
  218.         return(buffer);
  219.         }
  220.  
  221.     i=checkvar(word);
  222.     if(i<0)
  223.         *buffer=0;
  224.     else
  225.         strcpy(buffer,strb[i].buffer);
  226.  
  227.     return(buffer);
  228. }
  229. /*-------------------------------------------------------------*/
  230.  
  231. int gettoken(char *buffer,int len,char *option)
  232. {
  233. int ret=0,i;
  234. char htext[512],*p;
  235.  
  236.     strncpy(htext,buffer,len); *(htext+len)=0;
  237.     p=htext; 
  238.     while(*p) {
  239.         if (*p==' ') { *p++=0; break; }
  240.         p++;
  241.         }
  242.     if (option) strcpy(option,p);
  243.     i=0; while (c_tokens[i].number) {
  244.         if (!strcmp(c_tokens[i].token,htext)) {
  245.             ret=c_tokens[i].number; break;
  246.             }
  247.         i++;
  248.         }
  249. #ifdef DEBUG
  250.     fprintf(df,"\"%s\"(%s) ->%d\n",htext,option,ret);
  251. #endif
  252.  
  253.     return(ret);
  254. }
  255. /*-------------------------------------------------------------*/
  256.  
  257. int file_exist(char *name)
  258. {
  259. int fd;
  260.  
  261.     fd=open(name,O_RDONLY);
  262.     if (fd>0) {
  263.         close(fd); return(1);
  264.         } else return(0);
  265. }
  266. /*-------------------------------------------------------------*/
  267.  
  268. int my_wgetnstr(WINDOW *wi,char *buffer,int max_length)
  269. {
  270. char *p;
  271. int c;
  272.  
  273.     p=buffer;
  274.     if (!max_length)
  275.         max_length=wi->_maxx-wi->_curx;
  276.     if (max_length<0)
  277.         max_length=wi->_maxx-wi->_curx+max_length;
  278.     while (1) {
  279.         c=wgetch(wi);
  280.         if (c=='\n' || c=='\r') {
  281.             *p=0; break; }
  282.         if (c==' ') {
  283.             clearok(w,TRUE); wrefresh(w); continue; }
  284.         if (c==KEY_BACKSPACE || c=='' || c=='\177') {
  285.             if (p>buffer) {
  286.                 *p--=0; wi->_curx--; waddch(wi,' ');
  287.                 wi->_curx--; wrefresh(wi);
  288.                 continue;
  289.             } else {
  290.                 beep(); wrefresh(wi);
  291.                 }
  292.             continue;
  293.             }
  294.         if ((p-buffer)>=max_length) {
  295.             beep(); wrefresh(wi); continue; }
  296.         *p++=c;
  297.         waddch(wi,c); wrefresh(wi);
  298.         }
  299.     *p=0;
  300.     return(0);
  301. }
  302. /*-------------------------------------------------------------*/
  303.  
  304. int u_outc(WINDOW *wi,FILE *f,int c)
  305. {
  306. int rc;
  307.  
  308.     if (term && f==stdout) rc=waddch(wi,c);
  309.     else rc=putc(c,f);
  310.     return(rc);
  311. }
  312. /*-------------------------------------------------------------*/
  313.  
  314. int u_outs(WINDOW *wi,FILE *f,char *s)
  315. {
  316. int rc;
  317.  
  318.     if (term && f==stdout) rc=waddstr(wi,s);
  319.     else rc=fprintf(f,"%s",s);
  320.     return(rc);
  321. }
  322. /*-------------------------------------------------------------*/
  323.  
  324. char *lit_expand(char *buffer)
  325. {
  326. char helpbuffer[8192],help2[512],word[512],*s,*d,*q;
  327. int rc;
  328. FILE *pd;
  329.  
  330.     s=buffer; d=helpbuffer;
  331.     while(*s) {
  332.         switch(*s) {
  333.  
  334.             case '$' :
  335.                 q=getword(s+1,word);
  336.                 if (*word) {
  337.                     s++;
  338.                     getvar(word,help2); 
  339.                     strcpy(d,help2);
  340.                     d+=strlen(help2);
  341.                     if (q) s=q; else s+=strlen(word);
  342.                     } else s++;
  343.                 break;
  344.  
  345.             case '@' :
  346.                 s++;
  347.                 switch (*s) {
  348.                     case 't' :
  349.                         rc=atoi(getvar("_time",help2));
  350.                         rc-=atoi(getvar("_logon",help2));
  351.                         rc=atoi(getvar("_boxtime",help2))-rc/60;
  352.                         sprintf(help2,"%d",rc);
  353.                         strcpy(d,help2);
  354.                         d+=strlen(help2); s++;
  355.                         break;
  356.                         }
  357.                 break;
  358.  
  359.             case '`' :
  360.                 q=++s; while (*s!='`' && *s) s++;
  361.                 strncpy(help2,q,s-q);
  362.                 pd=popen(help2,"rt");
  363.                 if (pd) {
  364.                     while (1) {
  365.                         fgets(word,sizeof(word),pd);
  366.                         if (feof(pd)) break;
  367.                         strcpy(d,word);
  368.                         d+=strlen(word)-1;
  369.                         if (*d!='\n') d++;
  370.                         }
  371.                     pclose(pd);
  372.                     }
  373.                 s++;
  374.                 break;
  375.  
  376.             case '%' :
  377.                 q=getword(s+1,word);
  378.                 if (word) {
  379.                     s++;
  380.                     if (getenv(word))
  381.                         strcpy(help2,getenv(word)); 
  382.                         else *help2=0;
  383.                     strcpy(d,help2);
  384.                     d+=strlen(help2);
  385.                     if (q) s=q; else s+=strlen(word);
  386.                     } else s++;
  387.                 break;
  388.  
  389.             case '\\' :
  390.                 s++; *d++=*s++; break;
  391.  
  392.             default :
  393.                 *d++=*s++; break;
  394.  
  395.             }
  396.         }
  397.     *d=0;
  398.     strcpy(buffer,helpbuffer);
  399.     return(buffer);
  400. }
  401.  
  402. void wputolm(WINDOW *wi,char *buffer)
  403. {
  404. int x,y;
  405.     x=wi->_curx; y=wi->_cury;
  406.     mvwaddstr(wi,0,0,buffer);
  407.     wi->_curx=x; wi->_cury=y;
  408.     wrefresh(wi);
  409. }
  410.  
  411. void sig_USR1(void)
  412. { my_sig=SIGUSR1;
  413. /*
  414.     printf("SIGUSR1"); fflush(stdout);
  415.   signal(SIGUSR1,(void *)sig_USR1);
  416. */
  417. }
  418.  
  419. void sig_USR2(void)
  420. { my_sig=SIGUSR2;
  421.   signal(SIGUSR2,(void *)sig_USR2);
  422. }
  423.  
  424. /*-------------------------------------------------------------*/
  425.  
  426. void main(int argc, char* argv[])
  427. {
  428. FILE *fp,*pp;
  429. FILE *scr,*outf,*inpf;
  430. char filename[256],tmp[512],txt[512],options[512],*env,*p,*q;
  431. char inputfilename[512];
  432. char save_txt[MAXINCDEPTH][512],*save_p[MAXINCDEPTH];
  433. FILE *sf[MAXINCDEPTH];
  434. char word[512],command_token[512];
  435. int label_count,current_pos,re,i,j;
  436. char label_name[MAXLABELS][20];
  437. int label_pos[MAXLABELS];
  438. char label[512];
  439. int gc,dc,end_of_prg=0,bracket;
  440. int light,foreground,background,color;
  441. int hasc=0,never_in_term=1;
  442. int ilength;
  443. int pid;
  444. int ic;
  445. short fo,ba,found;
  446. int rc,cc,ccc,in_include;
  447. char pipebuffer[PIPEBUFFERSIZE],c;
  448. char tmpbuffer[INPUTBUFFERSIZE];
  449. char *cargv[32];
  450.  
  451.  
  452. #ifndef ST_VERSION
  453. #define ST_VERSION 0
  454. #endif
  455. #ifndef ST_SVERSION
  456. #define ST_SVERSION 0
  457. #endif
  458.  
  459.     while ((ic=getopt(argc,argv,"v?"))!=EOF) {
  460.         switch(ic) {
  461.             case 'v' :
  462.             case '?' :
  463.                 printf("showtext V%d.%02d\n",ST_VERSION,ST_SVERSION);
  464.                 printf("Usage : %s [-v?] [file]\n",argv[0]);
  465.                 exit(0); break;
  466.             }
  467.         }
  468.                 
  469.     if (optind>=argc) exit(0);
  470.     strcpy(inputfilename,argv[optind++]);
  471.  
  472.     for (rc=0;rc<MAXSTRBUFFER;rc++) {
  473.         strb[rc].buffername[0]=0;
  474.         strb[rc].buffer[0]=0;
  475.         }
  476.     strcpy(strb[0].buffername,"_error");
  477.     strcpy(strb[1].buffername,"_term");
  478.     strcpy(strb[2].buffername,"_level");
  479.     strcpy(strb[3].buffername,"_logon");
  480.     strcpy(strb[4].buffername,"_time");
  481.     strcpy(strb[5].buffername,"_boxtime");
  482.     strcpy(strb[6].buffername,"_left");
  483.  
  484.     if (getenv("TERM")) strcpy(strb[1].buffer,getenv("TERM"));
  485.     else strcpy(strb[1].buffer,"dumb");
  486.     if (getenv("boxlevel")) strcpy(strb[2].buffer,getenv("boxlevel"));
  487.     else strcpy(strb[2].buffer,"10");
  488.     if (getenv("logon_time")) strcpy(strb[3].buffer,getenv("logon_time"));
  489.     else sprintf(strb[3].buffer,"%d",(int)time(NULL));
  490.     sprintf(strb[4].buffer,"%d",(int)time(NULL));
  491.     if (getenv("boxtime")) strcpy(strb[5].buffer,getenv("boxtime"));
  492.     else strcpy(strb[5].buffer,"10");
  493.  
  494.     *label=0; *pipebuffer=0; gc=0;
  495.     ccc=1; cc=1; scr=stdout; outf=stdout; inpf=NULL;
  496.     in_include=0; save_p[0]=NULL; sf[0]=NULL;
  497.  
  498.     foreground=COLOR_WHITE; background=COLOR_BLACK;
  499.     light=0; color=0; label_count=0; current_pos=0;
  500.  
  501. #ifdef DEBUG
  502.     sprintf(filename,"/tmp/err.%d",getpid());
  503.     df=fopen(filename,"wt");
  504. #endif
  505.  
  506.     w=NULL;
  507.     if ((getenv("SHOWPATH"))==NULL)
  508.         strcpy(tmpbuffer,"/usr/lib/box");
  509.         else
  510.         strcpy(tmpbuffer,getenv("SHOWPATH"));
  511.     q=tmpbuffer+strlen(tmpbuffer)-1;
  512.     if (*q=='/') *q=0;
  513.     sprintf(filename,"%s/%s",tmpbuffer,inputfilename);
  514.  
  515.     signal(SIGUSR1,(void *)sig_USR1);
  516.     signal(SIGUSR2,(void *)sig_USR2);
  517.  
  518.     fp=fopen(filename,"rt");
  519.     if (!fp) {
  520.         sprintf(filename,"%s",inputfilename);
  521.         fp=fopen(filename,"rt");
  522.         }
  523.     if (fp) {
  524.  
  525.     /* scan labels */
  526.  
  527.         while(1) {
  528.             fgets(txt,sizeof(txt),fp);
  529.             if (feof(fp)) break;
  530.             if (*txt=='#') {
  531.                 current_pos+=strlen(txt);
  532.                 continue;
  533.                 }
  534.             re=strlen(txt);
  535.  
  536.             p=txt;
  537.             while (*p) {
  538.                 if (*p=='[') {
  539.                     q=++p; bracket=1;
  540.                     while(1) {
  541.                         if (*p==']') bracket--;
  542.                         if (*p=='[') bracket++;
  543.                         if (!bracket) break;
  544.                         p++;
  545.                         }
  546.                     if (*q=='/') {
  547.                         strncpy(label,q,p-q);
  548.                         *(label+(p-q))=0;
  549.                         strcpy(label_name[label_count],label+1);
  550.                         label_pos[label_count]=current_pos+(p-txt)+1;
  551. #ifdef DEBUG
  552.                         fprintf(df,"found label <%s> at %d (cp=%d)\n",
  553.                         label_name[label_count],label_pos[label_count],
  554.                         current_pos);
  555. #endif
  556.                         label_count++;
  557.                         *label=0;
  558.                         }
  559.                     }
  560.                 p++;
  561.                 }
  562.             current_pos+=re;
  563.             }
  564.  
  565.         rewind(fp); current_pos=0;
  566.  
  567.     /* scan tokens */
  568.  
  569.         while(1) {
  570.             fgets(txt,sizeof(txt),fp);
  571.             if (feof(fp)) break;
  572.             if (*txt=='#') {
  573.                 current_pos+=strlen(txt);
  574.                 continue;
  575.                 }
  576.             re=strlen(txt);
  577.             if (strlen(txt)>1) {
  578.                 p=txt+strlen(txt)-2;
  579.                 if (*p=='\\') *p=0;
  580.                 }
  581.  
  582.             p=txt;
  583.             while (*p) {
  584.                 if (*p=='\\') {
  585.                     p++;
  586.                     switch(*p) {
  587.                         case 'a' :    dc='\a'; break;
  588.                         case 'b' :    dc='\b'; break;
  589.                         case 'f' :    dc='\f'; break;
  590.                         case 'n' :    dc='\n'; break;
  591.                         case 'r' :    dc='\r'; break;
  592.                         case 't' :    dc='\t'; break;
  593.                         case 'v' :    dc='\v'; break;
  594.                         default  :    dc=*p; break;
  595.                         }
  596.                 } else
  597.                 if (*p=='[') {
  598.                     q=++p; bracket=1;
  599.                     while(1) {
  600.                         if (*p==']') bracket--;
  601.                         if (*p=='[') bracket++;
  602.                         if (!bracket) break;
  603.                         p++;
  604.                         }
  605.                     if (*q=='/') {
  606.                         p++;
  607.                         continue;
  608.                         }
  609.                     memmove(command_token,q,p-q);
  610.                     command_token[p-q]=0;    
  611.                     dc=gettoken(q,p-q,options);
  612.  
  613.                     if (dc>=C_FIRSTCOLOR && dc<=C_LASTCOLOR) {
  614.                         if (term && hasc) {
  615.                             foreground=dc-C_FIRSTCOLOR; light=0;
  616.                             if (foreground>7) {foreground&=7; light=1;}
  617.                             found=0;
  618.                             for (i=1;i<cc;i++) {
  619.                                 pair_content(i,&fo,&ba);
  620.                                 if (fo==foreground && ba==background) {
  621.                                     found=1; ccc=i; break; }
  622.                                 }
  623.                             if (!found) {
  624.                                 ccc=cc++;
  625.                                 init_pair(ccc,foreground,background);
  626.                                 }
  627.                             color=COLOR_PAIR(ccc);
  628.                             wrefresh(w);
  629.                             rc=wattron(w,color|(light?A_BOLD:0));
  630.                             if (!light) wattroff(w,A_BOLD);
  631.                             }
  632.                         } else
  633.  
  634.                     if (dc==C_BACKGROUND) {
  635.                         dc=gettoken(options,strlen(options),NULL);
  636.                         if (dc>=C_FIRSTCOLOR && dc<=C_LASTCOLOR) {
  637.                             if (term && hasc) {
  638.                                 background=(dc-C_FIRSTCOLOR)&7;
  639.                                 found=0;
  640.                                 for (i=1;i<cc;i++) {
  641.                                     pair_content(i,&fo,&ba);
  642.                                     if (fo==foreground && ba==background) {
  643.                                         found=1; ccc=i; break; }
  644.                                     }
  645.                                 if (!found) {
  646.                                     ccc=cc++;
  647.                                     init_pair(cc,foreground,background);
  648.                                     }
  649.                                 color=COLOR_PAIR(cc);
  650.                                 rc=wattron(w,color|(light?A_BOLD:0));
  651.                                 cc++;
  652.                                 }
  653.                             }
  654.                         } else
  655.  
  656.                     switch(dc) {
  657.  
  658.                         case 0 :
  659.                             q=getword(command_token,word);
  660.                             rc=checkvar(word);
  661.                             if (rc==-1) {
  662. #ifdef DEBUG
  663.                                 fprintf(df,"unknown token : <%s>\n",
  664.                                 word);
  665. #endif
  666.                                 break;
  667.                                 }
  668.                             getvar(word,tmpbuffer);
  669.                             rc=strlen(tmpbuffer); 
  670. #ifdef DEBUG
  671.                             fprintf(df,"found macro <%s> : <%s>\n",
  672.                             word,tmpbuffer);
  673. #endif
  674.                             if (rc) {
  675.                                 memmove(p+rc+1,p+1,strlen(p));
  676.                                 memmove(p+1,tmpbuffer,strlen(tmpbuffer));
  677.                                 }
  678.                             break;
  679.  
  680.                         case C_CLS : 
  681.                             if (term) wclear(w); break;
  682.  
  683.                         case C_TERM : 
  684.                             if (!term) {
  685.                                 if (never_in_term) {
  686.                                     w=initscr();
  687.                                     cbreak();
  688.                                     noecho();
  689.                                     keypad(w,TRUE);
  690.                                     leaveok(w,FALSE);
  691.                                     never_in_term=0;
  692.                                     hasc=has_colors();
  693.                                     if (hasc) start_color();
  694. #ifdef DEBUG
  695.                                     fprintf(df,"has_colors=%d\n",hasc);
  696. #endif
  697.                                 } else {
  698.                                     clearok(stdscr,TRUE);
  699.                                     fixterm(); wrefresh(w);
  700.                                     }
  701.                                 term=1;
  702.                                 }
  703.                             break;
  704.  
  705.                         case C_REFRESH : 
  706.                             if (term) wrefresh(w); break;
  707.  
  708.                         case C_GO_X :
  709.                             if (term) {
  710.                                 strcpy(tmpbuffer,options);
  711.                                 lit_expand(tmpbuffer);
  712.                                 i=atoi(tmpbuffer);
  713.                                 if (i>=0 && i<=w->_maxx)
  714.                                     w->_curx=i;
  715.                                 }
  716.                             break;
  717.  
  718.                         case C_GO_Y :
  719.                             if (term) {
  720.                                 strcpy(tmpbuffer,options);
  721.                                 lit_expand(tmpbuffer);
  722.                                 i=atoi(tmpbuffer);
  723.                                 if (i>=0 && i<=w->_maxy)
  724.                                     w->_cury=i;
  725.                                 }
  726.                             break;
  727.  
  728.                         case C_C_EOL : 
  729.                             if (term) wclrtoeol(w); break;
  730.  
  731.                         case C_C_BOT : 
  732.                             if (term) wclrtobot(w); break;
  733.  
  734.                         case C_GOTO :
  735.                             if (*options)
  736.                                 if (*options!='/') {
  737.                                     strcpy_labelname(label,options,gc);
  738.                                     }
  739.                             i=-1;
  740.                             for (j=0;j<label_count;j++) {
  741.                                 if (!strcmp(label_name[j],label)) {
  742.                                     i=label_pos[j]; break;
  743.                                     }
  744.                                 }
  745.                             if (i>=0) {
  746.                                 fseek(fp,i,SEEK_SET);
  747.                                 current_pos=i;
  748.                                 *label=0; *p=0;
  749.                                 continue;
  750.                                 }
  751. #ifdef DEBUG
  752.                                 fprintf(df,"label \"%s\" not found!\n",label);
  753. #endif
  754.                             break;
  755.  
  756.                         case C_GETKEY : 
  757.                             if (*options) {
  758.                                 strcpy(tmpbuffer,options);
  759.                                 lit_expand(tmpbuffer);
  760.                                 } else *tmpbuffer=0;
  761.                             if (term) {
  762.                                 wrefresh(w);
  763.                                 while(1) {
  764.                                     gc=wgetch(w);
  765.                                     if (gc==ERR || gc==EINTR) break;
  766.                                     if (*tmpbuffer) {
  767.                                         if (!strchr(tmpbuffer,gc)) {
  768.                                             if (gc==' ') clearok(w,TRUE);
  769.                                             beep(); wrefresh(w); }
  770.                                             else break;
  771.                                         } else break;
  772.                                 }
  773.                                 /*
  774.                                 if (my_sig) {
  775.                                     wputolm(w,"laber"); my_sig=0;}
  776.                                     */
  777.  
  778.                             } else {
  779.                                 gc=getchar();
  780.                                 if (*tmpbuffer)
  781.                                     while (!strchr(tmpbuffer,gc))
  782.                                         gc=getchar();
  783.                                 }
  784.                             *tmpbuffer=gc; *(tmpbuffer+1)=0;
  785.                             setvar("_Key",tmpbuffer);
  786.                             *tmpbuffer=tolower(*tmpbuffer);
  787.                             setvar("_key",tmpbuffer);
  788.                             break;
  789.  
  790.                         case C_GETSTR : 
  791.                             q=getword(options,word);
  792.                             ilength=atoi(word);
  793.                             if (q) strcpy(word,q);
  794.                                 else *word=0;
  795.                             if (term) {
  796.                                 wrefresh(w);
  797.                                 my_wgetnstr(w,tmpbuffer,ilength);
  798.                             } else fgets(tmpbuffer,sizeof(tmpbuffer),stdin);
  799.                             q=tmpbuffer+strlen(tmpbuffer)-1;
  800.                             if (*q=='\n') *q=0;
  801.                             setvar(word,tmpbuffer);
  802.                             break;
  803.  
  804.                         case C_PAUSE :
  805.                             if (!*options || !term) break;
  806.                             strcpy(tmpbuffer,options);
  807.                             lit_expand(tmpbuffer);
  808.                             rc=atoi(tmpbuffer);
  809.                             if ((w->_maxy-w->_cury)>rc) break;
  810.                             *tmpbuffer=0;
  811.  
  812.                         case C_WAIT : 
  813.                             if (dc==C_WAIT)
  814.                                 strcpy(tmpbuffer,options);
  815.                             if (!*tmpbuffer) getvar("_wait",tmpbuffer);
  816.                             if (!*tmpbuffer) strcpy(tmpbuffer,"more ");
  817.                             lit_expand(tmpbuffer);
  818.  
  819.                             if (term) {
  820.                                 u_outs(w,scr,tmpbuffer);
  821.                                 wrefresh(w);
  822.                                 c=0; /* wtimeout(w,1000); */
  823.                                 while (c!=13 && c!=10) {
  824. #ifndef USE_OWN_GETC
  825.                                     c=wgetch(w);
  826. #ifdef DEBUG
  827.                                     fprintf(df,"nach wgetch(w):%d\n",my_sig);
  828.                                     fflush(df);
  829. #endif
  830. #else
  831.                                     c=getchar();
  832. #ifdef DEBUG
  833.                                     fprintf(df,"nach getchar():%d\n",my_sig);
  834.                                     fflush(df);
  835. #endif
  836. #endif
  837.                                     if (my_sig) {
  838.                                         wputolm(w,"bla");
  839.                                         wrefresh(w); my_sig=0;
  840. #ifdef DEBUG
  841.                                         fprintf(df,"refreshed\n");
  842. #endif
  843.                                         }
  844.                                     }
  845.                                 if (dc==C_PAUSE) wclear(w);
  846.                             } else {
  847.                                 printf(tmpbuffer);
  848.                                 c=getchar();
  849.                             }
  850.                             break;
  851.  
  852.                         case C_NORMAL :
  853.                             if (term) {
  854.                                 foreground=COLOR_WHITE; background=COLOR_BLACK;
  855.                                 light=0;
  856.                                 wattrset(w,A_NORMAL);
  857.                                 }
  858.                             break;
  859.  
  860.                         case C_NOBOLD :
  861.                             if (term)
  862.                                 wattroff(w,A_BOLD);
  863.                             break;
  864.  
  865.                         case C_BOLD :
  866.                             if (term)
  867.                                 wattron(w,A_BOLD);
  868.                             break;
  869.  
  870.                         case C_NOBLINK :
  871.                             if (term)
  872.                                 wattroff(w,A_BLINK);
  873.                             break;
  874.  
  875.                         case C_BLINK :
  876.                             if (term)
  877.                                 wattron(w,A_BLINK);
  878.                             break;
  879.  
  880.                         case C_INVERS :
  881.                             if (term) {
  882.                                 wattron(w,A_REVERSE);
  883.                                 }
  884.                             break;
  885.  
  886.                         case C_NOINVERS :
  887.                             if (term) {
  888.                                 wattroff(w,A_REVERSE);
  889.                                 }
  890.                             break;
  891.  
  892.                         case C_ENV :
  893.                             env=getenv(options);
  894.                             if (env)
  895.                                 u_outs(w,scr,env);
  896.                             setvar("_error",env?"":"1");
  897.                             break;
  898.  
  899.                         case C_LOGIN :
  900.                             strcpy(tmp,getenv("LOGNAME"));
  901.                             u_outs(w,scr,tmp);
  902.                             break;
  903.  
  904.                         case C_NOTERM :
  905.                             if (term) {
  906.                                 refresh();
  907.                                 saveterm(); resetterm();
  908.                                 term=0;
  909.                                 }
  910.                             break;
  911.  
  912.                         case C_SYSTEM :
  913.                             strcpy(tmpbuffer,options);
  914.                             lit_expand(tmpbuffer);
  915.                             rc=system(tmpbuffer);
  916.                             *tmpbuffer=0;
  917.                             if (rc) sprintf(tmpbuffer,"%d",errno);
  918.                             setvar("_error",tmpbuffer);
  919.                             break;
  920.  
  921.                         case C_SPAWN :
  922.                         case C_EXEC :
  923.                             i=0;
  924.                             strcpy(tmp,options);
  925.                             lit_expand(tmp);
  926.                             q=getword(tmp,word);
  927.                             strcpy(tmpbuffer,word);
  928.                             cargv[0]=tmpbuffer; cargv[1]=NULL;
  929.                             while(q) {
  930.                                 i++;
  931.                                 cargv[i]=cargv[i-1]+strlen(cargv[i-1])+1;
  932.                                 q=getword(q,word);
  933.                                 if (word) strcpy(cargv[i],word);
  934.                                 cargv[i+1]=NULL;
  935.                                 }
  936. #ifdef DEBUG
  937.                             i=0; while(cargv[i]) {
  938.                                 fprintf(df,"%d:%s\n",i,cargv[i]);
  939.                                 i++; }
  940. #endif
  941.                             if (dc==C_SPAWN)
  942.                                 if ((pid=fork()))
  943.                                     break;
  944. #ifdef DEBUG
  945.                             if (df) fclose(df);
  946. #endif
  947.                             execvp(cargv[0],cargv);
  948.                             perror("exec");
  949.                             sprintf(tmpbuffer,"%d",errno);
  950.                             setvar("_error",tmpbuffer);
  951.                             break;
  952.  
  953.                         case C_PIPE :
  954.                         case C_PPIPE :
  955.                             strcpy(tmpbuffer,options);
  956.                             lit_expand(tmpbuffer);
  957.                             pp=popen(tmpbuffer,"r");
  958.                             if (pp) {
  959.                                 env=pipebuffer;
  960.                                 while(1) {
  961.                                     fgets(env,PIPEBUFFERSIZE-(env-pipebuffer-1),pp);
  962.                                     if (feof(pp)) break;
  963.                                     while (*env) env++;
  964.                                     if ((PIPEBUFFERSIZE-(env-pipebuffer-1))<1)
  965.                                         break;
  966.                                     }
  967.                                 pclose(pp);
  968.                                 env=pipebuffer+strlen(pipebuffer)-1;
  969.                                 if (*env=='\n') *env=0;
  970.                                 if (dc==C_PPIPE)
  971.                                     u_outs(w,scr,pipebuffer);
  972.                                 *tmpbuffer=0;
  973.                                 } else sprintf(tmpbuffer,"%d",errno);
  974.                             setvar("_error",tmpbuffer);
  975.                             break;
  976.  
  977.                         case C_SET :
  978.                             if (!*options) break;
  979.                             q=getword(options,word);
  980.                             *tmpbuffer=0;
  981.                             if (q) strcpy(tmpbuffer,q);
  982.                             lit_expand(tmpbuffer);
  983.                             setvar(word,tmpbuffer);
  984.                             break;
  985.  
  986.                         case C_UNSET :
  987.                             if (!*options) break;
  988.                             unsetvar(options);
  989.                             break;
  990.  
  991.                         case C_OSTR :
  992.                             u_outs(w,scr,getvar(options,tmpbuffer));
  993.                             break;
  994.  
  995.                         case C_OSTRI :
  996.                             strcpy(tmpbuffer,options);
  997.                             lit_expand(tmpbuffer);
  998.                             u_outs(w,scr,tmpbuffer);
  999.                             break;
  1000.  
  1001.                         case C_OKEY :
  1002.                             u_outc(w,scr,gc);
  1003.                             break;
  1004.  
  1005.                         case C_OSTRC :
  1006.                             getvar(options,tmpbuffer);
  1007.                             if (term)
  1008.                                 w->_curx=(w->_maxx-strlen(tmpbuffer))/2;
  1009.                             u_outs(w,scr,getvar(options,tmpbuffer));
  1010.                             break;
  1011.  
  1012.                         case C_TRUNCR :
  1013.                             getvar(options,tmpbuffer);
  1014.                             q=tmpbuffer+strlen(tmpbuffer)-1;
  1015.                             while(q>=tmpbuffer && *q==' ') *(q--)=0;
  1016.                             setvar(options,tmpbuffer);
  1017.                             break;
  1018.  
  1019.                         case C_TRUNCL :
  1020.                             getvar(options,tmpbuffer);
  1021.                             q=tmpbuffer;
  1022.                             while(*q && *q==' ') q++;
  1023.                             setvar(options,q);
  1024.                             break;
  1025.  
  1026.                         case C_IFZERO :
  1027.                         case C_IFNZERO :
  1028.                             rc=atoi(getvar(options,tmpbuffer));
  1029.                             if (dc==C_IFZERO && rc) *(p+1)=0;
  1030.                             if (dc==C_IFNZERO && !rc) *(p+1)=0;
  1031.                             break;
  1032.  
  1033.                         case C_ADVANCE :
  1034.                             q=getword(options,word);
  1035.                             if (!q) break;
  1036.                             strcpy(tmp,q); lit_expand(tmp);
  1037.                             rc=atoi(getvar(word,tmpbuffer));
  1038.                             rc+=atoi(tmp);
  1039.                             sprintf(tmpbuffer,"%d",rc);
  1040.                             setvar(word,tmpbuffer);
  1041.                             break;
  1042.  
  1043.                         case C_IFGT :
  1044.                         case C_IFNGT :
  1045.                             q=getword(options,word);
  1046.                             if (!q) { *(p+1)=0; break; }
  1047.                             strcpy(tmp,q); lit_expand(tmp);
  1048.                             rc=atoi(getvar(word,tmpbuffer));
  1049.                             if (dc==C_IFGT && rc<=atoi(tmp)) *(p+1)=0;
  1050.                             if (dc==C_IFNGT && rc>atoi(tmp)) *(p+1)=0;
  1051.                             break;
  1052.  
  1053.                         case C_IFEQ :
  1054.                         case C_IFNEQ :
  1055.                             q=getword(options,word);
  1056.                             if (!q) { *(p+1)=0; break; }
  1057.                             getvar(word,tmpbuffer);
  1058.                             strcpy(tmp,q); lit_expand(tmp);
  1059.                             rc=strcmp(tmpbuffer,tmp);
  1060.                             if (dc==C_IFEQ && rc) *(p+1)=0;
  1061.                             if (dc==C_IFNEQ && !rc) *(p+1)=0;
  1062.                             break;
  1063.  
  1064.                         case C_IFEMPTY :
  1065.                         case C_IFNEMPTY :
  1066.                             getvar(options,tmpbuffer);
  1067.                             if (dc==C_IFEMPTY && *tmpbuffer) *(p+1)=0;
  1068.                             if (dc==C_IFNEMPTY && !*tmpbuffer) *(p+1)=0;
  1069.                             break;
  1070.  
  1071.                         case C_OPIPE :
  1072.                             u_outs(w,scr,pipebuffer); break;
  1073.  
  1074.                         case C_OPEN :
  1075.                             if (*options) {
  1076.                                 strcpy(tmpbuffer,options);
  1077.                                 lit_expand(tmpbuffer);
  1078.                                 outf=fopen(tmpbuffer,"wt");
  1079.                                 if(outf) *tmpbuffer=0;
  1080.                                 else sprintf(tmpbuffer,"%d",errno);
  1081.                                 setvar("_error",tmpbuffer);
  1082.                                 }
  1083.                             break;
  1084.  
  1085.                         case C_APPEND :
  1086.                             if (*options) {
  1087.                                 strcpy(tmpbuffer,options);
  1088.                                 lit_expand(tmpbuffer);
  1089.                                 outf=fopen(tmpbuffer,"at");
  1090.                                 sprintf(tmpbuffer,"%d",errno);
  1091.                                 setvar("_error",tmpbuffer);
  1092.                                 }
  1093.                             break;
  1094.  
  1095.                         case C_IOPEN :
  1096.                             if (*options) {
  1097.                                 if (inpf) fclose(inpf);
  1098.                                 strcpy(tmpbuffer,options);
  1099.                                 lit_expand(tmpbuffer);
  1100. #ifdef DEBUG
  1101.                                 fprintf(df,"iopen \"%s\"",tmpbuffer);
  1102. #endif
  1103.                                 inpf=fopen(tmpbuffer,"rt");
  1104.                                 if (!inpf) {
  1105.                                     sprintf(tmpbuffer,"%d",errno);
  1106. #ifdef DEBUG
  1107.                                     fprintf(df," %s\n",strerror(errno));
  1108. #endif
  1109.                                 } else {
  1110. #ifdef DEBUG
  1111.                                     fprintf(df," opened\n");
  1112. #endif
  1113.                                     *tmpbuffer=0;
  1114.                                     }
  1115.                                 setvar("_error",tmpbuffer);
  1116.                                 }
  1117.                             break;
  1118.  
  1119.                         case C_IGETSTR :
  1120.                             if (inpf) {
  1121.                                 fgets(tmpbuffer,sizeof(tmpbuffer),inpf);
  1122.                                 setvar("_error","");
  1123.                                 if (feof(inpf)) {
  1124.                                     *tmpbuffer=0;
  1125.                                     setvar("_error","1");
  1126.                                     }
  1127.                                 q=tmpbuffer+strlen(tmpbuffer)-1;
  1128.                                 if (*q=='\n') *q=0;
  1129.                                 } else setvar("_errno","2");
  1130.                             setvar(options,tmpbuffer);
  1131.                             break;
  1132.  
  1133.                         case C_IFTERM :
  1134.                             strcpy(tmpbuffer,options);
  1135.                             lit_expand(tmpbuffer);
  1136.                             if (strcmp(getenv("TERM"),tmpbuffer))
  1137.                                 *(p+1)=0;
  1138.                             break;
  1139.  
  1140.                         case C_IFEX :
  1141. #ifdef DEBUG
  1142.                             fprintf(df,"file_check(%s)\n",options);
  1143. #endif
  1144.                             strcpy(tmpbuffer,options);
  1145.                             lit_expand(tmpbuffer);
  1146.                             if (!file_exist(tmpbuffer))
  1147.                                 *(p+1)=0;
  1148.                             break;
  1149.  
  1150.                         case C_REDIR :
  1151.                             if (outf) scr=outf;
  1152.                             break;
  1153.  
  1154.                         case C_UNREDIR :
  1155.                             scr=stdout;
  1156.                             break;
  1157.  
  1158.                         case C_EXIT :
  1159.                             if (in_include) {
  1160.                                 fclose(fp); in_include--;
  1161.                                 strcpy(txt,save_txt[in_include]);
  1162.                                 p=save_p[in_include];
  1163.                                 fp=sf[in_include];
  1164.                                 break; }
  1165.                             end_of_prg=1;
  1166.                             break;
  1167.  
  1168.                         case C_INCLUDE :
  1169.                             if (in_include>=MAXINCDEPTH) break;
  1170.                             sf[in_include]=fp; fp=fopen(options,"rt");
  1171. #ifdef DEBUG
  1172.                             fprintf(df,"including %s\n",options);
  1173. #endif
  1174.                             if (!fp) {
  1175. #ifdef DEBUG
  1176.                                 fprintf(df,"include %s:%s\n",options,
  1177.                                 strerror(errno));
  1178. #endif
  1179.                                 fp=sf[in_include]; break; }
  1180.                             save_p[in_include]=p;
  1181.                             strcpy(save_txt[in_include],txt);
  1182.                             p=txt; *(p+1)=0; in_include++;
  1183.                             break;
  1184.  
  1185.                         case C_CLOSE :
  1186.                             if (!outf) {
  1187.                                 scr=stdout;
  1188.                                 fclose(outf);
  1189.                                 outf=NULL;
  1190.                                 }
  1191.                             break;
  1192.  
  1193.                         case C_IREWIND :
  1194.                             if (inpf) {
  1195.                                 fseek(inpf,0L,SEEK_SET);
  1196.                                 }
  1197.                             break;
  1198.  
  1199.                         case C_ICLOSE :
  1200.                             if (inpf) {
  1201.                                 fclose(inpf);
  1202.                                 inpf=NULL;
  1203.                                 }
  1204.                             break;
  1205.  
  1206.                         }
  1207.                     dc=0;
  1208.                     } else {
  1209.                     dc=*p;
  1210.                     }
  1211.                 if (end_of_prg) break;
  1212.                 p++;
  1213.                 if (dc) {
  1214.                     rc=u_outc(w,scr,dc);
  1215.                     }
  1216.                 }
  1217.             /* end of former func show() */
  1218.  
  1219.             if (end_of_prg) break;
  1220.             current_pos+=re;
  1221.             }
  1222.         fclose(fp);
  1223.         } else {
  1224.         perror(filename);
  1225.         }
  1226.     if (term) endwin();
  1227. }
  1228.